package LC;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Design and implement a data structure for Least Recently Used (LRU) cache.
 * It should support the following operations: get and put.
 * get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
 * put(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity,
 * it should invalidate the least recently used item before inserting a new item.
 * Follow up:
 * Could you do both operations in O(1) time complexity?
 * Example:
 * LRUCache cache = new LRUCache( 2 );
 * cache.put(1,1);
 * cache.put(2,2);
 * cache.get(1);       // returns 1
 * cache.put(3,3);    // evicts key 2
 * cache.get(2);       // returns -1 (not found)
 * cache.put(4,4);    // evicts key 1
 * cache.get(1);       // returns -1 (not found)
 * cache.get(3);       // returns 3
 * cache.get(4);       // returns 4
 */

public class LC_146_LRUCache_Design {

    public static void main(String[] args) {

    }

    public class LRUCache extends LinkedHashMap<Integer, Integer> {
        private int maxcapacity;

        public LRUCache(int capacity) {
            super(capacity, 0.75f, true);
            this.maxcapacity = capacity;
        }

        public int get(int key) {
            Integer vaule = super.get(key);
            if (vaule == null) return -1;
            else return vaule;
        }

        public void set(int key, int value) {
            super.put(key, value);
        }

        protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
            return size() > maxcapacity;
        }
    }
}